home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / tex / tools / dvi / slm.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-22  |  5.1 KB  |  167 lines
  1. /***************************************************************************/
  2. /*                                                                         */
  3. /* Hardwareabhängiger Teil des DVI-Druckertreibers von Stefan Lindner      */
  4. /* Anpassung für Atari Laserdrucker SLM804 von Lutz Birkhahn               */
  5. /* Optimierter Atari Lasertreiber von Σ-soft, Markus Fritze                */
  6. /* Anpassung für DVI-100 von Markus Pristovsek                             */
  7. /*                                                                         */
  8. /*    0.90 (07.09.1988): Diablo 630 - Funktionen implementiert             */
  9. /*    1.0  (10.12.1988): Anpassungen an neue Treiberkern-Version           */
  10. /*    1.1  (13.01.1989): - " -: top_offset und left_offset eingeführt      */
  11. /*    1.2  (23.04.1989): left_skip und Top_skip entfernt.                  */
  12. /*    1.3  (20.05.1989): MRF: Eigenen Lasertreiber implementiert (V1.0)    */
  13. /*    1.4  (15.07.1993): MP: Angepaß für meinen Treiber, noch ungetestet,  */
  14. /*                       aber die Bitmap sieht richtig aus.                */
  15. /*                                                                         */
  16. /*    ACHTUNG: Darf nicht in's TT-RAM geladen werden!                                             */
  17. /*                                                                         */
  18. /***************************************************************************/
  19.  
  20.  
  21. #include <portab.h>
  22. #include <string.h>
  23.  
  24. #include "mintbind.h"
  25. #include "treiber.h"
  26.  
  27. /**** Aus ASSLASER.S ****/
  28. extern void print_laser(int *); /* Druckt die Bitmap des Lasers */
  29. extern int check_laser(void);   /* True, wenn Laser an */
  30.  
  31. /**** Assembler zur Vergrößerung ****/
  32. extern void kop2_1( void *quell, long quellweite, void *ziel );
  33. extern char    tmp_file[256]; /* In Datei drucken? */
  34.  
  35. #define LINKS    59L
  36. #define OBEN    89L
  37. #define HOEHE    3386L
  38. #define WEITE    2336L
  39. #define WWEITE 146L
  40. #define MAX_DPI    300L
  41.  
  42.     /* Diese wird an den Drucker geschickt */
  43. WORD    bitmap[494794L];
  44. WORD    tmp_zeile[WWEITE];
  45. char    display_status[4]="\033H*";
  46.  
  47.  
  48. /* Datei ausdrucken */
  49. WORD    drucke( UBYTE *p, LONG weite, LONG max_zeile, LONG h_dpi, LONG v_dpi )
  50. {
  51.     LONG        i, j, max_spalte;
  52.  
  53.     /* Kann logischerweise nicht in Datei drucken */
  54.     if(  tmp_file[0]>0  )
  55.     {
  56.         Cconws( "\007SLM kann nicht in eine Datei drucken!\xD" );
  57.         return 0;
  58.     }
  59.  
  60.     /* Nicht angeschaltet? => kein Druck! */
  61.     if(  !check_laser()  )
  62.     {
  63.         Cconws( "\007Laser nicht angeschlossen!\xD" );
  64.         return 0;
  65.     }
  66.     Cconws( display_status );
  67.     display_status[2] ^= 1;
  68.  
  69.         /* Horizontale Auflösung: 75,150,300 DpI */
  70.     if(  h_dpi>175  )
  71.         h_dpi = 300;
  72.     else if(  h_dpi>100  )
  73.         h_dpi = 150;
  74.     else 
  75.         h_dpi = 75;
  76.  
  77.         /* Vertikale Auflösung: 75,100,150,300 DpI */
  78.     if(  v_dpi>175  )
  79.         v_dpi = 300;
  80.     else if(  v_dpi>110  )
  81.         v_dpi = 150;
  82.     else if(  v_dpi>80  )
  83.         v_dpi = 100;
  84.     else
  85.         v_dpi = 75;
  86.  
  87.         /* Unsinnige Werte werden als Maximum angenommen */
  88.     if(  h_dpi<=0  ||  h_dpi>MAX_DPI  )
  89.         h_dpi = MAX_DPI;
  90.     if(  v_dpi<=0  ||  v_dpi>MAX_DPI  )
  91.         v_dpi = MAX_DPI;
  92.  
  93.         /* Bitmapanfang entsprechend verschieben */
  94.     weite = (weite+15)/16;
  95.     weite *= 2;
  96.     p += (weite*OBEN) + (LINKS/8);    /* Nicht druckbare Ränder*/
  97.     max_spalte = weite-(LINKS/8);
  98.     max_zeile -= OBEN+1;
  99.  
  100.     memset( bitmap, 0, 3386L*WWEITE*2 );
  101.         /* Anfang feststellen */
  102.     for(  j=0;  j<max_zeile  &&  ist_leerzeile( p, max_spalte );  j++  )
  103.         p += weite;
  104.     i = (j*MAX_DPI)/v_dpi;
  105.  
  106.     while(  i<HOEHE  &&  j<max_zeile  )
  107.     {
  108.         if(  (i%500)==0  )
  109.         {
  110.             Cconws( display_status );
  111.             display_status[2] ^= 1;
  112.         }
  113.  
  114.         switch( (WORD)h_dpi )
  115.         {
  116.             case 300:    if(  max_spalte>WWEITE*2  )
  117.                                     memcpy( bitmap+i*WWEITE, p, WWEITE*2 );
  118.                                 else
  119.                                     memcpy( bitmap+i*WWEITE, p, max_spalte );
  120.                             break;
  121.             case 150:    memset( tmp_zeile, 0, WWEITE*2 );
  122.                                 if(  max_spalte>WWEITE  )
  123.                                     kop2_1( p, WWEITE, tmp_zeile );
  124.                                 else
  125.                                     kop2_1( p, max_spalte, tmp_zeile );
  126.                                 memcpy( bitmap+i*WWEITE, tmp_zeile, WWEITE*2 );
  127.                             break;
  128.             case 75:    memset( tmp_zeile, 0, WWEITE );
  129.                                 if(  max_spalte>WWEITE/2  )
  130.                                     kop2_1( p, WWEITE/2, tmp_zeile );
  131.                                 else
  132.                                     kop2_1( p, max_spalte, tmp_zeile );
  133.                                 kop2_1( bitmap+i*WWEITE, WWEITE, tmp_zeile );
  134.                             break;
  135.         }
  136.         switch( (WORD)v_dpi )
  137.         {
  138.             case 300:    /* Nix */
  139.                                 i++;
  140.                             break;
  141.                                 /* Letzte Zeile kopieren */
  142.             case 150:    memcpy( bitmap+(i+1L)*WWEITE, bitmap+i*WWEITE, 2*WWEITE );
  143.                                 i += 2;
  144.                             break;
  145.                                 /* Letzten beiden Zeile kopieren */
  146.             case 100: memcpy( bitmap+(i+1L)*WWEITE, bitmap+i*WWEITE, 2*WWEITE );
  147.                                 memcpy( bitmap+(i+2L)*WWEITE, bitmap+i*WWEITE, 2*WWEITE );
  148.                                 i += 3;
  149.                             break;
  150.                                 /* Letzten drei Zeile kopieren */
  151.             case 75:     memcpy( bitmap+(i+1L)*WWEITE, bitmap+i*WWEITE, 2*WWEITE );
  152.                                 memcpy( bitmap+(i+2L)*WWEITE, bitmap+i*WWEITE, 2*WWEITE );
  153.                                 memcpy( bitmap+(i+3L)*WWEITE, bitmap+i*WWEITE, 2*WWEITE );
  154.                                 i += 4;
  155.                             break;
  156.         }
  157.         p += weite;
  158.         j++;
  159.     }
  160.  
  161.     Cconws( display_status );
  162.   print_laser(bitmap);    /* Bitmap 2336x3386 drucken (in Assembler) */
  163.     return 0;
  164. }
  165.  
  166.  
  167.